package condition

import "reflect"

// 私有方法
func reflectValue(val any) bool {
	switch rv := reflect.ValueOf(val).Elem(); rv.Kind() {
	case reflect.Map, reflect.Slice:
		return rv.Len() != 0
	default:
		is := rv.IsZero()
		return !is
	}
}

// Bool 转换成bool
// value 泛型类型值
// 返回bool值
func Bool[T any](value T) bool {
	switch m := any(value).(type) {
	case interface{ Bool() bool }:
		return m.Bool()
	case interface{ IsZero() bool }:
		return !m.IsZero()
	}
	return reflectValue(&value)
}

// And 同时判断两个值是否为真
// a, b 泛型类型值
// 返回bool值
func And[T, U any](a T, b U) bool {
	return Bool(a) && Bool(b)
}

// Or 同时判断两个值是否为假
// a, b 泛型类型值
// 返回bool值
func Or[T, U any](a T, b U) bool {
	return Bool(a) || Bool(b)
}

// Xor 异或判断两个值是否为真
// a, b 泛型类型值
// 返回bool值
func Xor[T, U any](a T, b U) bool {
	return Bool(a) != Bool(b)
}

// Nor 同时判断两个值是否为假
// a, b 泛型类型值
// 返回bool值
func Nor[T, U any](a T, u U) bool {
	return !(Bool(a) || Bool(u))
}

// XNor 同时判断两个值是否为真
// a, b 泛型类型值
// 返回bool值
func XNor[T, U any](a T, u U) bool {
	return Bool(a) == Bool(u)
}

// NotAnd 同时判断两个值是否为假
// a, b 泛型类型值
// 返回bool值
func NotAnd[T, U any](a T, u U) bool {
	return !Bool(a) || !Bool(u)
}

// Judgment 条件判断
// isTrue bool类型值
// ifValue 泛型类型值
// elseValue 泛型类型值
// 返回泛型类型值
func Judgment[T, U any](isTrue T, ifValue U, elseValue U) U {
	if Bool(isTrue) {
		return ifValue
	}
	return elseValue
}

// InArray 判断某个元素是否在数组中存在
// val 待判断元素
// arr 数组
// 返回bool
func InArray[T comparable](val T, arr ...T) bool {
	for _, v := range arr {
		if v == val {
			return true
		}
	}
	return false
}

// IsContainChinese 判断是否是中文
func IsContainChinese(str string) bool {
	for _, r := range str {
		if r > '\u4e00' && r < '\u9fa5' {
			return true
		}
	}
	return false
}
